﻿// TestLibDill.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include "libdill.h"
#include "assert.h"
#if defined(OS_WINDOWS)
#include <Windows.h>
#endif
static coroutine void worker(int count, const char* text) {
   int i;
   for (i = 0; i != count; ++i) {
       printf("ww in=%s\n", text);
      int rc = msleep(1);
       printf("ww out=%s\n", text);
      // errno_assert(rc == 0 || errno == ECANCELED);
   }
   printf("ww out122=%s\n", text);
}
static coroutine void worker2(int count, const char* text) {
   int i;
   for (i = 0; i != count; ++i) {
       printf("ww in=%s\n", text);
        int rc = msleep(1);
       printf("ww out=%s\n", text);
       // errno_assert(rc == 0 || errno == ECANCELED);
   }
     printf("ww out33333=%s\n", text);
}

coroutine void worker1(void) {
}

int main() {
   /*volatile int dill_unoptimisable1 = 1;
   int dill_anchor[dill_unoptimisable1]*/

   //  int hndl7 = bundle();
   //  char stk[4096];
   //    int rc = dill_go_mem(worker(4, "a "), stk, sizeof(stk));
   //  // int hndl8 = bundle();
   //    char stk2[4096];
   //   int  rc2 = dill_go_mem(worker(4, "a "), stk2, sizeof(stk2));

  
   printf("1111\n");
   go(worker(4, "a "));
   printf("22222\n");
   go(worker2(2, "b"));
   printf("33333\n");
    go(worker(3, "c"));
    printf("4444\n");
    msleep(2000);
  
 /*  rc = hclose(cr1);
 
   rc = hclose(cr2);
 
   rc = hclose(cr3);*/
   //msleep(122220);
   std::cout << "Hello World!\n";
#if defined(OS_WINDOWS)
   Sleep(122222222222222);
#else
   while (true)
   {
       msleep(100);
   }
#endif
   return 0;
}



// #include <stdio.h>
// #include <stdlib.h>
// #include <windows.h>

// #define STACK_SIZE 16384

// volatile int unoptimisable_ = 1;

// struct cr_ {
//     struct cr_* next;
//     CONTEXT ctx;
// };

// struct cr_ main_cr_ = { NULL };

// struct cr_* first_cr_ = &main_cr_;
// struct cr_* last_cr_ = &main_cr_;

// #define go(fn) \
//     do { \
//         if(!setjmp((first_cr_->ctx).ContextRecord)) { \
//             char* stack = (char*)malloc(STACK_SIZE); \
//             int anchor_[unoptimisable_]; \
//             char filler_[(char*)&anchor_ - (char*)(stack + STACK_SIZE)]; \
//             struct cr_* cr = (struct cr_*)malloc(sizeof(struct cr_)); \
//             cr->next = first_cr_; \
//             first_cr_ = cr; \
//             char* stack_[unoptimisable_]; \
//             stack_[0] = stack; \
//             fn; \
//             free(stack_[0]); \
//             first_cr_ = first_cr_->next; \
//             longjmp((first_cr_->ctx).ContextRecord, 1); \
//         } \
//     } while(0)

// void yield(void) {
//     if (first_cr_ == last_cr_)
//         return;
//     if (setjmp((first_cr_->ctx).ContextRecord))
//         return;
//     struct cr_* cr = first_cr_;
//     first_cr_ = cr->next;
//     cr->next = NULL;
//     last_cr_->next = cr;
//     last_cr_ = cr;
//     longjmp((first_cr_->ctx).ContextRecord, 1);
// }

// static void foo(int count, const char* text) {
//     int i;
//     for (i = 0; i != count; ++i) {
//         printf("%s\n", text);
//         yield();
//     }
// }

// int main() {
//     go(foo(3, "a"));
//     return 0;
// }